/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.catalina.manager.host;

import org.apache.catalina.*;
import org.apache.catalina.core.ContainerBase;
import org.apache.catalina.core.StandardHost;
import org.apache.catalina.startup.HostConfig;
import org.apache.tomcat.util.ExceptionUtils;
import org.apache.tomcat.util.modeler.Registry;
import org.apache.tomcat.util.res.StringManager;

import javax.management.MBeanServer;
import javax.servlet.ServletException;
import javax.servlet.UnavailableException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.util.Enumeration;
import java.util.Locale;
import java.util.StringTokenizer;

/**
 * Servlet that enables remote management of the virtual hosts installed
 * on the server.  Normally, this functionality will be protected by
 * a security constraint in the web application deployment descriptor.
 * However, this requirement can be relaxed during testing.
 * <p>
 * This servlet examines the value returned by <code>getPathInfo()</code>
 * and related query parameters to determine what action is being requested.
 * The following actions and parameters (starting after the servlet path)
 * are supported:
 * <ul>
 * <li><b>/add?name={host-name}&aliases={host-aliases}&manager={manager}</b> -
 * Create and add a new virtual host. The <code>host-name</code> attribute
 * indicates the name of the new host. The <code>host-aliases</code>
 * attribute is a comma separated list of the host alias names.
 * The <code>manager</code> attribute is a boolean value indicating if the
 * webapp manager will be installed in the newly created host (optional,
 * false by default).</li>
 * <li><b>/remove?name={host-name}</b> - Remove a virtual host.
 * The <code>host-name</code> attribute indicates the name of the host.
 * </li>
 * <li><b>/list</b> - List the virtual hosts installed on the server.
 * Each host will be listed with the following format
 * <code>host-name#host-aliases</code>.</li>
 * <li><b>/start?name={host-name}</b> - Start the virtual host.</li>
 * <li><b>/stop?name={host-name}</b> - Stop the virtual host.</li>
 * </ul>
 * <p>
 * <b>NOTE</b> - Attempting to stop or remove the host containing
 * this servlet itself will not succeed.  Therefore, this servlet should
 * generally be deployed in a separate virtual host.
 * <p>
 * The following servlet initialization parameters are recognized:
 * <ul>
 * <li><b>debug</b> - The debugging detail level that controls the amount
 * of information that is logged by this servlet.  Default is zero.
 * </ul>
 *
 * @author Craig R. McClanahan
 * @author Remy Maucherat
 */
public class HostManagerServlet
		extends HttpServlet implements ContainerServlet {

	/**
	 * The string manager for this package.
	 */
	protected static final StringManager sm =
			StringManager.getManager(Constants.Package);

	// ----------------------------------------------------- Instance Variables
	private static final long serialVersionUID = 1L;
	/**
	 * The Context container associated with our web application.
	 */
	protected transient Context context = null;
	/**
	 * The debugging detail level for this servlet.
	 */
	protected int debug = 1;
	/**
	 * The associated host.
	 */
	protected transient Host installedHost = null;
	/**
	 * The associated engine.
	 */
	protected transient Engine engine = null;
	/**
	 * MBean server.
	 */
	protected transient MBeanServer mBeanServer = null;
	/**
	 * The Wrapper container associated with this servlet.
	 */
	protected transient Wrapper wrapper = null;


	// ----------------------------------------------- ContainerServlet Methods

	/**
	 * Return the Wrapper with which we are associated.
	 */
	@Override
	public Wrapper getWrapper() {

		return (this.wrapper);

	}

	/**
	 * Set the Wrapper with which we are associated.
	 *
	 * @param wrapper The new wrapper
	 */
	@Override
	public void setWrapper(Wrapper wrapper) {

		this.wrapper = wrapper;
		if (wrapper == null) {
			context = null;
			installedHost = null;
			engine = null;
		} else {
			context = (Context) wrapper.getParent();
			installedHost = (Host) context.getParent();
			engine = (Engine) installedHost.getParent();
		}

		// Retrieve the MBean server
		mBeanServer = Registry.getRegistry(null, null).getMBeanServer();

	}


	// --------------------------------------------------------- Public Methods

	/**
	 * Finalize this servlet.
	 */
	@Override
	public void destroy() {

		// No actions necessary

	}

	/**
	 * Process a GET request for the specified resource.
	 *
	 * @param request  The servlet request we are processing
	 * @param response The servlet response we are creating
	 * @throws IOException      if an input/output error occurs
	 * @throws ServletException if a servlet-specified error occurs
	 */
	@Override
	public void doGet(HttpServletRequest request,
	                  HttpServletResponse response)
			throws IOException, ServletException {

		StringManager smClient = StringManager.getManager(
				Constants.Package, request.getLocales());

		// Identify the request parameters that we need
		String command = request.getPathInfo();
		if (command == null)
			command = request.getServletPath();
		String name = request.getParameter("name");

		// Prepare our output writer to generate the response message
		response.setContentType("text/plain; charset=" + Constants.CHARSET);
		PrintWriter writer = response.getWriter();

		// Process the requested command
		if (command == null) {
			writer.println(sm.getString("hostManagerServlet.noCommand"));
		} else if (command.equals("/add")) {
			add(request, writer, name, false, smClient);
		} else if (command.equals("/remove")) {
			remove(writer, name, smClient);
		} else if (command.equals("/list")) {
			list(writer, smClient);
		} else if (command.equals("/start")) {
			start(writer, name, smClient);
		} else if (command.equals("/stop")) {
			stop(writer, name, smClient);
		} else {
			writer.println(sm.getString("hostManagerServlet.unknownCommand",
					command));
		}

		// Finish up the response
		writer.flush();
		writer.close();

	}

	/**
	 * Add host with the given parameters.
	 *
	 * @param request  The request
	 * @param writer   The output writer
	 * @param name     The host name
	 * @param htmlMode Flag value
	 */
	protected void add(HttpServletRequest request, PrintWriter writer,
	                   String name, boolean htmlMode, StringManager smClient) {
		String aliases = request.getParameter("aliases");
		String appBase = request.getParameter("appBase");
		boolean manager = booleanParameter(request, "manager", false, htmlMode);
		boolean autoDeploy = booleanParameter(request, "autoDeploy", true, htmlMode);
		boolean deployOnStartup = booleanParameter(request, "deployOnStartup", true, htmlMode);
		boolean deployXML = booleanParameter(request, "deployXML", true, htmlMode);
		boolean unpackWARs = booleanParameter(request, "unpackWARs", true, htmlMode);
		boolean copyXML = booleanParameter(request, "copyXML", false, htmlMode);
		add(writer, name, aliases, appBase, manager,
				autoDeploy,
				deployOnStartup,
				deployXML,
				unpackWARs,
				copyXML,
				smClient);
	}

	/**
	 * Extract boolean value from checkbox with default.
	 *
	 * @param request
	 * @param parameter
	 * @param theDefault
	 * @param htmlMode
	 */
	protected boolean booleanParameter(HttpServletRequest request,
	                                   String parameter, boolean theDefault, boolean htmlMode) {
		String value = request.getParameter(parameter);
		boolean booleanValue = theDefault;
		if (value != null) {
			if (htmlMode) {
				if (value.equals("on")) {
					booleanValue = true;
				}
			} else if (theDefault) {
				if (value.equals("false")) {
					booleanValue = false;
				}
			} else if (value.equals("true")) {
				booleanValue = true;
			}
		} else if (htmlMode)
			booleanValue = false;
		return booleanValue;
	}

	/**
	 * Initialize this servlet.
	 */
	@Override
	public void init() throws ServletException {

		// Ensure that our ContainerServlet properties have been set
		if ((wrapper == null) || (context == null))
			throw new UnavailableException
					(sm.getString("hostManagerServlet.noWrapper"));

		// Set our properties from the initialization parameters
		String value = null;
		try {
			value = getServletConfig().getInitParameter("debug");
			debug = Integer.parseInt(value);
		} catch (Throwable t) {
			ExceptionUtils.handleThrowable(t);
		}

	}


	// -------------------------------------------------------- Private Methods

	/**
	 * Add a host using the specified parameters.
	 *
	 * @param writer  Writer to render results to
	 * @param name    host name
	 * @param aliases comma separated alias list
	 * @param appBase application base for the host
	 * @param manager should the manager webapp be deployed to the new host ?
	 */
	protected synchronized void add
	(PrintWriter writer, String name, String aliases, String appBase,
	 boolean manager,
	 boolean autoDeploy,
	 boolean deployOnStartup,
	 boolean deployXML,
	 boolean unpackWARs,
	 boolean copyXML,
	 StringManager smClient) {
		if (debug >= 1) {
			log(sm.getString("hostManagerServlet.add", name));
		}

		// Validate the requested host name
		if ((name == null) || name.length() == 0) {
			writer.println(smClient.getString(
					"hostManagerServlet.invalidHostName", name));
			return;
		}

		// Check if host already exists
		if (engine.findChild(name) != null) {
			writer.println(smClient.getString(
					"hostManagerServlet.alreadyHost", name));
			return;
		}

		// Validate and create appBase
		File appBaseFile = null;
		File file = null;
		String applicationBase = appBase;
		if (applicationBase == null || applicationBase.length() == 0) {
			applicationBase = name;
		}
		file = new File(applicationBase);
		if (!file.isAbsolute())
			file = new File(System.getProperty(Globals.CATALINA_BASE_PROP), file.getPath());
		try {
			appBaseFile = file.getCanonicalFile();
		} catch (IOException e) {
			appBaseFile = file;
		}
		if (!appBaseFile.mkdirs() && !appBaseFile.isDirectory()) {
			writer.println(smClient.getString(
					"hostManagerServlet.appBaseCreateFail",
					appBaseFile.toString(), name));
			return;
		}

		// Create base for config files
		File configBaseFile = getConfigBase(name);

		// Copy manager.xml if requested
		if (manager) {
			if (configBaseFile == null) {
				writer.println(smClient.getString(
						"hostManagerServlet.configBaseCreateFail", name));
				return;
			}
			InputStream is = null;
			OutputStream os = null;
			try {
				is = getServletContext().getResourceAsStream("/manager.xml");
				os = new FileOutputStream(new File(configBaseFile, "manager.xml"));
				byte buffer[] = new byte[512];
				int len = buffer.length;
				while (true) {
					len = is.read(buffer);
					if (len == -1)
						break;
					os.write(buffer, 0, len);
				}
			} catch (IOException e) {
				writer.println(smClient.getString(
						"hostManagerServlet.managerXml"));
				return;
			} finally {
				if (is != null) {
					try {
						is.close();
					} catch (IOException e) {
						// Ignore
					}
				}
				if (os != null) {
					try {
						os.close();
					} catch (IOException e) {
						// Ignore
					}
				}
			}
		}

		StandardHost host = new StandardHost();
		host.setAppBase(applicationBase);
		host.setName(name);

		host.addLifecycleListener(new HostConfig());

		// Add host aliases
		if ((aliases != null) && !("".equals(aliases))) {
			StringTokenizer tok = new StringTokenizer(aliases, ", ");
			while (tok.hasMoreTokens()) {
				host.addAlias(tok.nextToken());
			}
		}
		host.setAutoDeploy(autoDeploy);
		host.setDeployOnStartup(deployOnStartup);
		host.setDeployXML(deployXML);
		host.setUnpackWARs(unpackWARs);
		host.setCopyXML(copyXML);

		// Add new host
		try {
			engine.addChild(host);
		} catch (Exception e) {
			writer.println(smClient.getString("hostManagerServlet.exception",
					e.toString()));
			return;
		}

		host = (StandardHost) engine.findChild(name);
		if (host != null) {
			writer.println(smClient.getString("hostManagerServlet.add", name));
		} else {
			// Something failed
			writer.println(smClient.getString(
					"hostManagerServlet.addFailed", name));
		}

	}

	/**
	 * Remove the specified host.
	 *
	 * @param writer Writer to render results to
	 * @param name   host name
	 */
	protected synchronized void remove(PrintWriter writer, String name,
	                                   StringManager smClient) {

		if (debug >= 1) {
			log(sm.getString("hostManagerServlet.remove", name));
		}

		// Validate the requested host name
		if ((name == null) || name.length() == 0) {
			writer.println(smClient.getString(
					"hostManagerServlet.invalidHostName", name));
			return;
		}

		// Check if host exists
		if (engine.findChild(name) == null) {
			writer.println(smClient.getString(
					"hostManagerServlet.noHost", name));
			return;
		}

		// Prevent removing our own host
		if (engine.findChild(name) == installedHost) {
			writer.println(smClient.getString(
					"hostManagerServlet.cannotRemoveOwnHost", name));
			return;
		}

		// Remove host
		// Note that the host will not get physically removed
		try {
			Container child = engine.findChild(name);
			engine.removeChild(child);
			if (child instanceof ContainerBase) ((ContainerBase) child).destroy();
		} catch (Exception e) {
			writer.println(smClient.getString("hostManagerServlet.exception",
					e.toString()));
			return;
		}

		Host host = (StandardHost) engine.findChild(name);
		if (host == null) {
			writer.println(smClient.getString(
					"hostManagerServlet.remove", name));
		} else {
			// Something failed
			writer.println(smClient.getString(
					"hostManagerServlet.removeFailed", name));
		}

	}

	/**
	 * Render a list of the currently active Contexts in our virtual host.
	 *
	 * @param writer Writer to render to
	 */
	protected void list(PrintWriter writer, StringManager smClient) {

		if (debug >= 1) {
			log(sm.getString("hostManagerServlet.list", engine.getName()));
		}

		writer.println(smClient.getString("hostManagerServlet.listed",
				engine.getName()));
		Container[] hosts = engine.findChildren();
		for (int i = 0; i < hosts.length; i++) {
			Host host = (Host) hosts[i];
			String name = host.getName();
			String[] aliases = host.findAliases();
			StringBuilder buf = new StringBuilder();
			if (aliases.length > 0) {
				buf.append(aliases[0]);
				for (int j = 1; j < aliases.length; j++) {
					buf.append(',').append(aliases[j]);
				}
			}
			writer.println(smClient.getString("hostManagerServlet.listitem",
					name, buf.toString()));
		}
	}

	/**
	 * Start the host with the specified name.
	 *
	 * @param writer Writer to render to
	 * @param name   Host name
	 */
	protected void start(PrintWriter writer, String name,
	                     StringManager smClient) {

		if (debug >= 1) {
			log(sm.getString("hostManagerServlet.start", name));
		}

		// Validate the requested host name
		if ((name == null) || name.length() == 0) {
			writer.println(smClient.getString(
					"hostManagerServlet.invalidHostName", name));
			return;
		}

		Container host = engine.findChild(name);

		// Check if host exists
		if (host == null) {
			writer.println(smClient.getString(
					"hostManagerServlet.noHost", name));
			return;
		}

		// Prevent starting our own host
		if (host == installedHost) {
			writer.println(smClient.getString(
					"hostManagerServlet.cannotStartOwnHost", name));
			return;
		}

		// Don't start host if already started
		if (host.getState().isAvailable()) {
			writer.println(smClient.getString(
					"hostManagerServlet.alreadyStarted", name));
			return;
		}

		// Start host
		try {
			host.start();
			writer.println(smClient.getString(
					"hostManagerServlet.started", name));
		} catch (Exception e) {
			getServletContext().log
					(sm.getString("hostManagerServlet.startFailed", name), e);
			writer.println(smClient.getString(
					"hostManagerServlet.startFailed", name));
			writer.println(smClient.getString(
					"hostManagerServlet.exception", e.toString()));
			return;
		}

	}

	/**
	 * Stop the host with the specified name.
	 *
	 * @param writer Writer to render to
	 * @param name   Host name
	 */
	protected void stop(PrintWriter writer, String name,
	                    StringManager smClient) {

		if (debug >= 1) {
			log(sm.getString("hostManagerServlet.stop", name));
		}

		// Validate the requested host name
		if ((name == null) || name.length() == 0) {
			writer.println(smClient.getString(
					"hostManagerServlet.invalidHostName", name));
			return;
		}

		Container host = engine.findChild(name);

		// Check if host exists
		if (host == null) {
			writer.println(smClient.getString("hostManagerServlet.noHost",
					name));
			return;
		}

		// Prevent stopping our own host
		if (host == installedHost) {
			writer.println(smClient.getString(
					"hostManagerServlet.cannotStopOwnHost", name));
			return;
		}

		// Don't stop host if already stopped
		if (!host.getState().isAvailable()) {
			writer.println(smClient.getString(
					"hostManagerServlet.alreadyStopped", name));
			return;
		}

		// Stop host
		try {
			host.stop();
			writer.println(smClient.getString("hostManagerServlet.stopped",
					name));
		} catch (Exception e) {
			getServletContext().log(sm.getString(
					"hostManagerServlet.stopFailed", name), e);
			writer.println(smClient.getString("hostManagerServlet.stopFailed",
					name));
			writer.println(smClient.getString("hostManagerServlet.exception",
					e.toString()));
			return;
		}

	}


	// -------------------------------------------------------- Support Methods

	/**
	 * Get config base.
	 */
	protected File getConfigBase(String hostName) {
		File configBase =
				new File(System.getProperty(Globals.CATALINA_BASE_PROP), "conf");
		if (!configBase.exists()) {
			return null;
		}
		if (engine != null) {
			configBase = new File(configBase, engine.getName());
		}
		if (installedHost != null) {
			configBase = new File(configBase, hostName);
		}
		if (!configBase.mkdirs() && !configBase.isDirectory()) {
			return null;
		}
		return configBase;
	}

	/**
	 * @deprecated Use {@link StringManager#getManager(String, Enumeration)}.
	 * This method will be removed in Tomcat 8.
	 */
	@Deprecated
	protected StringManager getStringManager(HttpServletRequest req) {
		Enumeration<Locale> requestedLocales = req.getLocales();
		while (requestedLocales.hasMoreElements()) {
			Locale locale = requestedLocales.nextElement();
			StringManager result = StringManager.getManager(Constants.Package,
					locale);
			if (result.getLocale().equals(locale)) {
				return result;
			}
		}
		// Return the default
		return sm;
	}
}
